package com.by.rpc.registry;//package com.by.common.rpc.registry;
//
//import com.by.common.rpc.dto.ServiceInstance;
//import com.alibaba.fastjson2.JSON;
//import lombok.extern.slf4j.Slf4j;
//
//import java.io.*;
//import java.nio.channels.FileChannel;
//import java.nio.channels.FileLock;
//import java.nio.file.Paths;
//import java.nio.file.StandardOpenOption;
//import java.util.ArrayList;
//import java.util.List;
//import java.util.Map;
//import java.util.HashMap;
//import java.util.concurrent.*;
//
///**
// * 基于共享内存（文件系统）的服务注册中心实现
// * 支持多进程间的服务注册与发现
// */
//@Slf4j
//public class SharedMemoryServiceRegistry implements ServiceRegistry {
//    // 共享文件路径
//    private static final String SHARED_FILE_PATH = System.getProperty("java.io.tmpdir") + "/rpc_registry.dat";
//
//    // API端点文件路径
//    private static final String API_ENDPOINTS_FILE_PATH = System.getProperty("java.io.tmpdir") + "/rpc_api_endpoints.dat";
//
//    // 心跳检测间隔（毫秒）
//    private static final long HEARTBEAT_INTERVAL = 10000;
//
//    // 服务实例心跳超时时间（毫秒）
//    private static final long SERVICE_TIMEOUT = 30000;
//
//    // 定时任务执行器
//    private final ScheduledExecutorService scheduler = Executors.newSingleThreadScheduledExecutor();
//
//    // 本地缓存的服务实例
//    private final ConcurrentHashMap<String, ServiceInstance> localServices = new ConcurrentHashMap<>();
//
//    // 本地缓存的API端点
//    private final ConcurrentHashMap<String, ApiEndpointInfo> localApiEndpoints = new ConcurrentHashMap<>();
//
//    public SharedMemoryServiceRegistry() {
//        // 启动心跳检测任务
//        startHeartbeat();
//        log.info("Shared memory service registry initialized with file: {}", SHARED_FILE_PATH);
//    }
//
//    @Override
//    public void register(ServiceInstance serviceInstance) {
//        String serviceKey = generateServiceKey(serviceInstance);
//        localServices.put(serviceKey, serviceInstance);
//        persistToFile();
//        log.info("Service registered: {}", serviceInstance);
//    }
//
//    @Override
//    public void deregister(ServiceInstance serviceInstance) {
//        String serviceKey = generateServiceKey(serviceInstance);
//        localServices.remove(serviceKey);
//        persistToFile();
//        log.info("Service deregistered: {}", serviceInstance);
//    }
//
//    @Override
//    public List<ServiceInstance> discover(String serviceName) {
//        // 从共享文件中读取最新的服务信息
//        List<ServiceInstance> allInstances = readFromFile();
//
//        // 过滤出指定服务且未过期的实例
//        long currentTime = System.currentTimeMillis();
//        List<ServiceInstance> result = new ArrayList<>();
//        for (ServiceInstance instance : allInstances) {
//            if (serviceName.equals(instance.getServiceName()) &&
//                (currentTime - instance.getRegisterTime()) < SERVICE_TIMEOUT) {
//                result.add(instance);
//            }
//        }
//
//        return result;
//    }
//
//    @Override
//    public void updateHeartbeat(ServiceInstance serviceInstance) {
//        String serviceKey = generateServiceKey(serviceInstance);
//        serviceInstance.setRegisterTime(System.currentTimeMillis());
//        localServices.put(serviceKey, serviceInstance);
//        persistToFile();
//        log.debug("Heartbeat updated for service: {}", serviceInstance);
//    }
//
//    @Override
//    public void registerApiEndpoint(String key, String value, int expireSeconds) {
//        ApiEndpointInfo endpointInfo = new ApiEndpointInfo(value, System.currentTimeMillis() + expireSeconds * 1000);
//        localApiEndpoints.put(key, endpointInfo);
//        persistApiEndpointsToFile();
//        log.info("API endpoint registered: {} -> {}", key, value);
//    }
//
//    @Override
//    public Map<String, String> discoverApiEndpoints(String pattern) {
//        // 从共享文件中读取最新的API端点信息
//        Map<String, ApiEndpointInfo> allEndpoints = readApiEndpointsFromFile();
//
//        Map<String, String> result = new HashMap<>();
//        long currentTime = System.currentTimeMillis();
//
//        for (Map.Entry<String, ApiEndpointInfo> entry : allEndpoints.entrySet()) {
//            String key = entry.getKey();
//            ApiEndpointInfo info = entry.getValue();
//
//            // 检查是否过期
//            if (currentTime < info.getExpireTime()) {
//                // 简单的模式匹配（实际项目中可以使用更复杂的匹配规则）
//                if (key.contains(pattern) || pattern.equals("*")) {
//                    result.put(key, info.getValue());
//                }
//            }
//        }
//
//        return result;
//    }
//
//    @Override
//    public Map<String, String> getAllServices() {
//        // 从共享文件中读取最新的API端点信息
//        Map<String, ApiEndpointInfo> allEndpoints = readApiEndpointsFromFile();
//
//        Map<String, String> result = new HashMap<>();
//        long currentTime = System.currentTimeMillis();
//
//        for (Map.Entry<String, ApiEndpointInfo> entry : allEndpoints.entrySet()) {
//            String key = entry.getKey();
//            ApiEndpointInfo info = entry.getValue();
//
//            // 检查是否过期
//            if (currentTime < info.getExpireTime()) {
//                result.put(key, info.getValue());
//            }
//        }
//
//        return result;
//    }
//
//    @Override
//    public ServiceInstance getInstance(String key) {
//        // 这个方法在共享内存实现中不太适用，因为存储的是API端点信息而不是ServiceInstance
//        // 这里返回null，实际使用中应该通过discover方法获取服务实例
//        return null;
//    }
//
//    @Override
//    public String getApiEndpoint(String key) {
//        // 从共享文件中读取最新的API端点信息
//        Map<String, ApiEndpointInfo> allEndpoints = readApiEndpointsFromFile();
//
//        long currentTime = System.currentTimeMillis();
//        ApiEndpointInfo info = allEndpoints.get(key);
//
//        // 检查是否存在且未过期
//        if (info != null && currentTime < info.getExpireTime()) {
//            return info.getValue();
//        }
//
//        return null;
//    }
//
//    /**
//     * 启动心跳检测任务
//     */
//    private void startHeartbeat() {
//        scheduler.scheduleAtFixedRate(() -> {
//            try {
//                // 更新本地服务的心跳时间
//                long currentTime = System.currentTimeMillis();
//                localServices.values().forEach(instance -> {
//                    instance.setRegisterTime(currentTime);
//                });
//
//                // 持久化到共享文件
//                if (!localServices.isEmpty()) {
//                    persistToFile();
//                }
//
//                // 清理过期API端点
//                cleanupExpiredApiEndpoints();
//
//                // 持久化API端点
//                if (!localApiEndpoints.isEmpty()) {
//                    persistApiEndpointsToFile();
//                }
//
//                // 清理过期服务
//                cleanupExpiredServices();
//            } catch (Exception e) {
//                log.error("Failed to perform heartbeat check", e);
//            }
//        }, HEARTBEAT_INTERVAL, HEARTBEAT_INTERVAL, TimeUnit.MILLISECONDS);
//    }
//
//    /**
//     * 清理过期服务
//     */
//    private void cleanupExpiredServices() {
//        long currentTime = System.currentTimeMillis();
//        localServices.entrySet().removeIf(entry ->
//            (currentTime - entry.getValue().getRegisterTime()) >= SERVICE_TIMEOUT);
//    }
//
//    /**
//     * 清理过期API端点
//     */
//    private void cleanupExpiredApiEndpoints() {
//        long currentTime = System.currentTimeMillis();
//        localApiEndpoints.entrySet().removeIf(entry ->
//            currentTime >= entry.getValue().getExpireTime());
//    }
//
//    /**
//     * 将服务实例持久化到共享文件
//     */
//    private void persistToFile() {
//        FileChannel channel = null;
//        FileLock lock = null;
//
//        try {
//            // 创建文件通道
//            channel = FileChannel.open(
//                Paths.get(SHARED_FILE_PATH),
//                StandardOpenOption.CREATE,
//                StandardOpenOption.WRITE,
//                StandardOpenOption.TRUNCATE_EXISTING
//            );
//
//            // 获取文件锁，确保多进程写入安全
//            lock = channel.lock();
//
//            // 准备要写入的数据
//            List<ServiceInstance> allInstances = new ArrayList<>(localServices.values());
//
//            // 读取现有数据并合并
//            List<ServiceInstance> existingInstances = readFromFileInternal(channel);
//            for (ServiceInstance existing : existingInstances) {
//                String existingKey = generateServiceKey(existing);
//                if (!localServices.containsKey(existingKey)) {
//                    // 添加来自其他进程的服务实例（如果未过期）
//                    if ((System.currentTimeMillis() - existing.getRegisterTime()) < SERVICE_TIMEOUT) {
//                        allInstances.add(existing);
//                    }
//                }
//            }
//
//            // 序列化并写入文件
//            String jsonData = JSON.toJSONString(allInstances);
//            channel.truncate(0);
//            channel.write(java.nio.ByteBuffer.wrap(jsonData.getBytes("UTF-8")));
//
//        } catch (Exception e) {
//            log.error("Failed to persist service registry to file", e);
//        } finally {
//            // 释放锁和关闭通道
//            if (lock != null) {
//                try {
//                    lock.release();
//                } catch (IOException e) {
//                    log.error("Failed to release file lock", e);
//                }
//            }
//            if (channel != null) {
//                try {
//                    channel.close();
//                } catch (IOException e) {
//                    log.error("Failed to close file channel", e);
//                }
//            }
//        }
//    }
//
//    /**
//     * 将API端点信息持久化到共享文件
//     */
//    private void persistApiEndpointsToFile() {
//        FileChannel channel = null;
//        FileLock lock = null;
//
//        try {
//            // 创建文件通道
//            channel = FileChannel.open(
//                Paths.get(API_ENDPOINTS_FILE_PATH),
//                StandardOpenOption.CREATE,
//                StandardOpenOption.WRITE,
//                StandardOpenOption.TRUNCATE_EXISTING
//            );
//
//            // 获取文件锁，确保多进程写入安全
//            lock = channel.lock();
//
//            // 准备要写入的数据
//            Map<String, ApiEndpointInfo> allEndpoints = new HashMap<>(localApiEndpoints);
//
//            // 读取现有数据并合并
//            Map<String, ApiEndpointInfo> existingEndpoints = readApiEndpointsFromFileInternal(channel);
//            for (Map.Entry<String, ApiEndpointInfo> entry : existingEndpoints.entrySet()) {
//                String key = entry.getKey();
//                ApiEndpointInfo existingInfo = entry.getValue();
//                if (!localApiEndpoints.containsKey(key)) {
//                    // 添加来自其他进程的API端点（如果未过期）
//                    if (System.currentTimeMillis() < existingInfo.getExpireTime()) {
//                        allEndpoints.put(key, existingInfo);
//                    }
//                }
//            }
//
//            // 序列化并写入文件
//            String jsonData = JSON.toJSONString(allEndpoints);
//            channel.truncate(0);
//            channel.write(java.nio.ByteBuffer.wrap(jsonData.getBytes("UTF-8")));
//
//        } catch (Exception e) {
//            log.error("Failed to persist API endpoints to file", e);
//        } finally {
//            // 释放锁和关闭通道
//            if (lock != null) {
//                try {
//                    lock.release();
//                } catch (IOException e) {
//                    log.error("Failed to release file lock", e);
//                }
//            }
//            if (channel != null) {
//                try {
//                    channel.close();
//                } catch (IOException e) {
//                    log.error("Failed to close file channel", e);
//                }
//            }
//        }
//    }
//
//    /**
//     * 从共享文件中读取服务实例
//     */
//    private List<ServiceInstance> readFromFile() {
//        FileChannel channel = null;
//        FileLock lock = null;
//
//        try {
//            File file = new File(SHARED_FILE_PATH);
//            if (!file.exists()) {
//                return new ArrayList<>();
//            }
//
//            // 创建文件通道
//            channel = FileChannel.open(
//                Paths.get(SHARED_FILE_PATH),
//                StandardOpenOption.READ
//            );
//
//            // 获取共享锁
//            lock = channel.lock(0, Long.MAX_VALUE, true);
//
//            return readFromFileInternal(channel);
//        } catch (Exception e) {
//            log.error("Failed to read service registry from file", e);
//            return new ArrayList<>();
//        } finally {
//            // 释放锁和关闭通道
//            if (lock != null) {
//                try {
//                    lock.release();
//                } catch (IOException e) {
//                    log.error("Failed to release file lock", e);
//                }
//            }
//            if (channel != null) {
//                try {
//                    channel.close();
//                } catch (IOException e) {
//                    log.error("Failed to close file channel", e);
//                }
//            }
//        }
//    }
//
//    /**
//     * 从共享文件中读取API端点信息
//     */
//    private Map<String, ApiEndpointInfo> readApiEndpointsFromFile() {
//        FileChannel channel = null;
//        FileLock lock = null;
//
//        try {
//            File file = new File(API_ENDPOINTS_FILE_PATH);
//            if (!file.exists()) {
//                return new HashMap<>();
//            }
//
//            // 创建文件通道
//            channel = FileChannel.open(
//                Paths.get(API_ENDPOINTS_FILE_PATH),
//                StandardOpenOption.READ
//            );
//
//            // 获取共享锁
//            lock = channel.lock(0, Long.MAX_VALUE, true);
//
//            return readApiEndpointsFromFileInternal(channel);
//        } catch (Exception e) {
//            log.error("Failed to read API endpoints from file", e);
//            return new HashMap<>();
//        } finally {
//            // 释放锁和关闭通道
//            if (lock != null) {
//                try {
//                    lock.release();
//                } catch (IOException e) {
//                    log.error("Failed to release file lock", e);
//                }
//            }
//            if (channel != null) {
//                try {
//                    channel.close();
//                } catch (IOException e) {
//                    log.error("Failed to close file channel", e);
//                }
//            }
//        }
//    }
//
//    /**
//     * 从文件通道内部读取数据
//     */
//    private List<ServiceInstance> readFromFileInternal(FileChannel channel) {
//        try {
//            if (channel.size() == 0) {
//                return new ArrayList<>();
//            }
//
//            // 读取文件内容
//            java.nio.ByteBuffer buffer = java.nio.ByteBuffer.allocate((int) channel.size());
//            channel.read(buffer);
//            buffer.flip();
//
//            byte[] bytes = new byte[buffer.remaining()];
//            buffer.get(bytes);
//
//            String jsonData = new String(bytes, "UTF-8");
//            if (jsonData.trim().isEmpty()) {
//                return new ArrayList<>();
//            }
//
//            // 反序列化
//            return JSON.parseArray(jsonData, ServiceInstance.class);
//        } catch (Exception e) {
//            log.error("Failed to parse service registry data", e);
//            return new ArrayList<>();
//        }
//    }
//
//    /**
//     * 从文件通道内部读取API端点数据
//     */
//    private Map<String, ApiEndpointInfo> readApiEndpointsFromFileInternal(FileChannel channel) {
//        try {
//            if (channel.size() == 0) {
//                return new HashMap<>();
//            }
//
//            // 读取文件内容
//            java.nio.ByteBuffer buffer = java.nio.ByteBuffer.allocate((int) channel.size());
//            channel.read(buffer);
//            buffer.flip();
//
//            byte[] bytes = new byte[buffer.remaining()];
//            buffer.get(bytes);
//
//            String jsonData = new String(bytes, "UTF-8");
//            if (jsonData.trim().isEmpty()) {
//                return new HashMap<>();
//            }
//
//            // 反序列化
//            return JSON.parseObject(jsonData, new com.alibaba.fastjson2.TypeReference<Map<String, ApiEndpointInfo>>() {});
//        } catch (Exception e) {
//            log.error("Failed to parse API endpoints data", e);
//            return new HashMap<>();
//        }
//    }
//
//    /**
//     * 生成服务实例的唯一键
//     */
//    private String generateServiceKey(ServiceInstance instance) {
//        return instance.getServiceName() + ":" + instance.getHost() + ":" + instance.getPort();
//    }
//
//    /**
//     * 关闭注册中心
//     */
//    public void close() {
//        scheduler.shutdown();
//        try {
//            if (!scheduler.awaitTermination(5, TimeUnit.SECONDS)) {
//                scheduler.shutdownNow();
//            }
//        } catch (InterruptedException e) {
//            scheduler.shutdownNow();
//            Thread.currentThread().interrupt();
//        }
//
//        // 注销所有本地服务
//        localServices.values().forEach(this::deregister);
//        log.info("Shared memory service registry closed");
//    }
//
//    /**
//     * API端点信息内部类
//     */
//    private static class ApiEndpointInfo {
//        private String value;
//        private long expireTime;
//
//        public ApiEndpointInfo() {
//        }
//
//        public ApiEndpointInfo(String value, long expireTime) {
//            this.value = value;
//            this.expireTime = expireTime;
//        }
//
//        public String getValue() {
//            return value;
//        }
//
//        public void setValue(String value) {
//            this.value = value;
//        }
//
//        public long getExpireTime() {
//            return expireTime;
//        }
//
//        public void setExpireTime(long expireTime) {
//            this.expireTime = expireTime;
//        }
//    }
//}